/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('aegis-ops', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model CreateRtapCmdDispatchTaskRequest {
  aliUid?: long(name='AliUid'),
  bid?: string(name='Bid'),
  lang?: string(name='Lang'),
  params?: string(name='Params'),
  requestId?: string(name='RequestId'),
  taskName?: string(name='TaskName'),
  type?: string(name='Type'),
  uuids?: string(name='Uuids'),
}

model CreateRtapCmdDispatchTaskResponseBody = {
  code?: string(name='Code'),
  count?: int32(name='Count'),
  data?: [ 
    {
      aliUid?: long(name='AliUid'),
      process?: int32(name='Process'),
      result?: string(name='Result'),
      rootTaskId?: string(name='RootTaskId'),
      status?: string(name='Status'),
      taskId?: string(name='TaskId'),
      uuid?: string(name='Uuid'),
    }
  ](name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model CreateRtapCmdDispatchTaskResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateRtapCmdDispatchTaskResponseBody(name='body'),
}

async function createRtapCmdDispatchTaskWithOptions(request: CreateRtapCmdDispatchTaskRequest, runtime: Util.RuntimeOptions): CreateRtapCmdDispatchTaskResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.aliUid)) {
    body['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.bid)) {
    body['Bid'] = request.bid;
  }
  if (!Util.isUnset(request.lang)) {
    body['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.params)) {
    body['Params'] = request.params;
  }
  if (!Util.isUnset(request.requestId)) {
    body['RequestId'] = request.requestId;
  }
  if (!Util.isUnset(request.taskName)) {
    body['TaskName'] = request.taskName;
  }
  if (!Util.isUnset(request.type)) {
    body['Type'] = request.type;
  }
  if (!Util.isUnset(request.uuids)) {
    body['Uuids'] = request.uuids;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateRtapCmdDispatchTask',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createRtapCmdDispatchTask(request: CreateRtapCmdDispatchTaskRequest): CreateRtapCmdDispatchTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  return createRtapCmdDispatchTaskWithOptions(request, runtime);
}

model DescribeAssetDetailByUuidsRequest {
  aliUid?: long(name='AliUid'),
  bid?: string(name='Bid'),
  from?: string(name='From'),
  lang?: string(name='Lang'),
  requestId?: string(name='RequestId'),
  uuids?: string(name='Uuids'),
}

model DescribeAssetDetailByUuidsResponseBody = {
  code?: string(name='Code'),
  count?: int32(name='Count'),
  data?: [ 
    {
      alarmStatus?: string(name='AlarmStatus'),
      assetType?: string(name='AssetType'),
      assetTypeName?: string(name='AssetTypeName'),
      authModifyTime?: long(name='AuthModifyTime'),
      authVersion?: int32(name='AuthVersion'),
      authVersionName?: string(name='AuthVersionName'),
      bind?: boolean(name='Bind'),
      clientStatus?: string(name='ClientStatus'),
      clientVersion?: string(name='ClientVersion'),
      clusterId?: string(name='ClusterId'),
      clusterName?: string(name='ClusterName'),
      cores?: int32(name='Cores'),
      cpu?: int32(name='Cpu'),
      cpuInfo?: string(name='CpuInfo'),
      createdTime?: long(name='CreatedTime'),
      diskInfoList?: [ 
        {
          diskName?: string(name='DiskName'),
          totalSize?: long(name='TotalSize'),
          useSize?: long(name='UseSize'),
        }
      ](name='DiskInfoList'),
      exposedStatus?: int32(name='ExposedStatus'),
      flag?: int32(name='Flag'),
      groupId?: long(name='GroupId'),
      groupTrace?: string(name='GroupTrace'),
      hasContainer?: string(name='HasContainer'),
      hcStatus?: string(name='HcStatus'),
      healthCheckCount?: int32(name='HealthCheckCount'),
      hostName?: string(name='HostName'),
      importance?: int32(name='Importance'),
      instanceId?: string(name='InstanceId'),
      instanceName?: string(name='InstanceName'),
      internetIp?: string(name='InternetIp'),
      intranetIp?: string(name='IntranetIp'),
      ip?: string(name='Ip'),
      ipList?: [ string ](name='IpList'),
      ipListString?: string(name='IpListString'),
      kernel?: string(name='Kernel'),
      lastLoginTimestamp?: long(name='LastLoginTimestamp'),
      macList?: [ string ](name='MacList'),
      macListString?: string(name='MacListString'),
      mem?: int32(name='Mem'),
      memory?: int32(name='Memory'),
      os?: string(name='Os'),
      osDetail?: string(name='OsDetail'),
      osName?: string(name='OsName'),
      podCount?: int32(name='PodCount'),
      region?: string(name='Region'),
      regionId?: string(name='RegionId'),
      regionName?: string(name='RegionName'),
      riskCount?: string(name='RiskCount'),
      riskStatus?: string(name='RiskStatus'),
      safeEventCount?: int32(name='SafeEventCount'),
      status?: string(name='Status'),
      sysInfo?: string(name='SysInfo'),
      tag?: string(name='Tag'),
      tagId?: string(name='TagId'),
      uuid?: string(name='Uuid'),
      vendor?: int32(name='Vendor'),
      vendorName?: string(name='VendorName'),
      vpcInstanceId?: string(name='VpcInstanceId'),
      vulCount?: int32(name='VulCount'),
      vulStatus?: string(name='VulStatus'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DescribeAssetDetailByUuidsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeAssetDetailByUuidsResponseBody(name='body'),
}

async function describeAssetDetailByUuidsWithOptions(request: DescribeAssetDetailByUuidsRequest, runtime: Util.RuntimeOptions): DescribeAssetDetailByUuidsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.aliUid)) {
    body['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.bid)) {
    body['Bid'] = request.bid;
  }
  if (!Util.isUnset(request.from)) {
    body['From'] = request.from;
  }
  if (!Util.isUnset(request.lang)) {
    body['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.requestId)) {
    body['RequestId'] = request.requestId;
  }
  if (!Util.isUnset(request.uuids)) {
    body['Uuids'] = request.uuids;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAssetDetailByUuids',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAssetDetailByUuids(request: DescribeAssetDetailByUuidsRequest): DescribeAssetDetailByUuidsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAssetDetailByUuidsWithOptions(request, runtime);
}

model DescribeGraph4IncidentOnlineRequest {
  aliUid?: long(name='AliUid'),
  anomalyCount?: int32(name='AnomalyCount'),
  assetName?: string(name='AssetName'),
  incidentId?: string(name='IncidentId'),
  incidentName?: string(name='IncidentName'),
  incidentTime?: string(name='IncidentTime'),
  lang?: string(name='Lang'),
  securityEventIdList?: [ 
    {
      occurrenceTime?: string(name='OccurrenceTime'),
      uniqueInfo?: string(name='UniqueInfo'),
    }
  ](name='SecurityEventIdList'),
  uuid?: string(name='Uuid'),
  vertexId?: string(name='VertexId'),
}

model DescribeGraph4IncidentOnlineShrinkRequest {
  aliUid?: long(name='AliUid'),
  anomalyCount?: int32(name='AnomalyCount'),
  assetName?: string(name='AssetName'),
  incidentId?: string(name='IncidentId'),
  incidentName?: string(name='IncidentName'),
  incidentTime?: string(name='IncidentTime'),
  lang?: string(name='Lang'),
  securityEventIdListShrink?: string(name='SecurityEventIdList'),
  uuid?: string(name='Uuid'),
  vertexId?: string(name='VertexId'),
}

model DescribeGraph4IncidentOnlineResponseBody = {
  code?: string(name='Code'),
  data?: {
    edgeList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        endId?: string(name='EndId'),
        endType?: string(name='EndType'),
        name?: string(name='Name'),
        origin?: string(name='Origin'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        showType?: string(name='ShowType'),
        startId?: string(name='StartId'),
        startType?: string(name='StartType'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        typeName?: string(name='TypeName'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='EdgeList'),
    entityTypeList?: [ 
      {
        currentVersionId?: string(name='CurrentVersionId'),
        displayColor?: string(name='DisplayColor'),
        displayIcon?: string(name='DisplayIcon'),
        displayOrder?: int32(name='DisplayOrder'),
        displayTemplate?: string(name='DisplayTemplate'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: string(name='Id'),
        isVirtualNode?: int32(name='IsVirtualNode'),
        name?: string(name='Name'),
        namespace?: string(name='Namespace'),
        syncId?: int32(name='SyncId'),
        traceSuccessFlag?: int32(name='TraceSuccessFlag'),
      }
    ](name='EntityTypeList'),
    lang?: string(name='Lang'),
    relationTypeList?: [ 
      {
        currentVersionId?: string(name='CurrentVersionId'),
        directed?: int32(name='Directed'),
        displayColor?: string(name='DisplayColor'),
        displayIcon?: string(name='DisplayIcon'),
        displayTemplate?: string(name='DisplayTemplate'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: string(name='Id'),
        name?: string(name='Name'),
        namespace?: string(name='Namespace'),
        showType?: string(name='ShowType'),
        syncId?: int32(name='SyncId'),
      }
    ](name='RelationTypeList'),
    vertexList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        displayInfo?: [ 
          {
            name?: string(name='Name'),
            value?: string(name='Value'),
          }
        ](name='DisplayInfo'),
        id?: string(name='Id'),
        lang?: string(name='Lang'),
        name?: string(name='Name'),
        neighborList?: [ 
          {
            count?: int32(name='Count'),
            hasMore?: boolean(name='HasMore'),
            type?: string(name='Type'),
          }
        ](name='NeighborList'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='VertexList'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model DescribeGraph4IncidentOnlineResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeGraph4IncidentOnlineResponseBody(name='body'),
}

async function describeGraph4IncidentOnlineWithOptions(tmpReq: DescribeGraph4IncidentOnlineRequest, runtime: Util.RuntimeOptions): DescribeGraph4IncidentOnlineResponse {
  Util.validateModel(tmpReq);
  var request = new DescribeGraph4IncidentOnlineShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.securityEventIdList)) {
    request.securityEventIdListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.securityEventIdList, 'SecurityEventIdList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.anomalyCount)) {
    query['AnomalyCount'] = request.anomalyCount;
  }
  if (!Util.isUnset(request.assetName)) {
    query['AssetName'] = request.assetName;
  }
  if (!Util.isUnset(request.incidentId)) {
    query['IncidentId'] = request.incidentId;
  }
  if (!Util.isUnset(request.incidentName)) {
    query['IncidentName'] = request.incidentName;
  }
  if (!Util.isUnset(request.incidentTime)) {
    query['IncidentTime'] = request.incidentTime;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.securityEventIdListShrink)) {
    query['SecurityEventIdList'] = request.securityEventIdListShrink;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  if (!Util.isUnset(request.vertexId)) {
    query['VertexId'] = request.vertexId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeGraph4IncidentOnline',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeGraph4IncidentOnline(request: DescribeGraph4IncidentOnlineRequest): DescribeGraph4IncidentOnlineResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeGraph4IncidentOnlineWithOptions(request, runtime);
}

model DescribeGraph4InvestigationOnlineRequest {
  aliUid?: string(name='AliUid'),
  anomalyId?: string(name='AnomalyId'),
  anomalyUuid?: string(name='AnomalyUuid'),
  direction?: string(name='Direction'),
  fromTime?: int32(name='FromTime'),
  lang?: string(name='Lang'),
  pathLength?: int32(name='PathLength'),
  query?: string(name='Query'),
  ruleIdList?: [ string ](name='RuleIdList'),
  storeType?: string(name='StoreType'),
  toTime?: int32(name='ToTime'),
  uuid?: string(name='Uuid'),
  vertexId?: string(name='VertexId'),
  vertexIdList?: [ string ](name='VertexIdList'),
}

model DescribeGraph4InvestigationOnlineShrinkRequest {
  aliUid?: string(name='AliUid'),
  anomalyId?: string(name='AnomalyId'),
  anomalyUuid?: string(name='AnomalyUuid'),
  direction?: string(name='Direction'),
  fromTime?: int32(name='FromTime'),
  lang?: string(name='Lang'),
  pathLength?: int32(name='PathLength'),
  query?: string(name='Query'),
  ruleIdListShrink?: string(name='RuleIdList'),
  storeType?: string(name='StoreType'),
  toTime?: int32(name='ToTime'),
  uuid?: string(name='Uuid'),
  vertexId?: string(name='VertexId'),
  vertexIdListShrink?: string(name='VertexIdList'),
}

model DescribeGraph4InvestigationOnlineResponseBody = {
  code?: string(name='Code'),
  data?: {
    edgeList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        endId?: string(name='EndId'),
        endType?: string(name='EndType'),
        name?: string(name='Name'),
        origin?: string(name='Origin'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        showType?: string(name='ShowType'),
        startId?: string(name='StartId'),
        startType?: string(name='StartType'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        typeName?: string(name='TypeName'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='EdgeList'),
    entityTypeList?: [ 
      {
        currentVersionId?: string(name='CurrentVersionId'),
        displayColor?: string(name='DisplayColor'),
        displayIcon?: string(name='DisplayIcon'),
        displayOrder?: int32(name='DisplayOrder'),
        displayTemplate?: string(name='DisplayTemplate'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: string(name='Id'),
        isVirtualNode?: int32(name='IsVirtualNode'),
        name?: string(name='Name'),
        namespace?: string(name='Namespace'),
        syncId?: int32(name='SyncId'),
        traceSuccessFlag?: int32(name='TraceSuccessFlag'),
      }
    ](name='EntityTypeList'),
    lang?: string(name='Lang'),
    relationTypeList?: [ 
      {
        currentVersionId?: string(name='CurrentVersionId'),
        directed?: int32(name='Directed'),
        displayColor?: string(name='DisplayColor'),
        displayIcon?: string(name='DisplayIcon'),
        displayTemplate?: string(name='DisplayTemplate'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: string(name='Id'),
        name?: string(name='Name'),
        namespace?: string(name='Namespace'),
        showType?: string(name='ShowType'),
        syncId?: int32(name='SyncId'),
      }
    ](name='RelationTypeList'),
    vertexList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        displayInfo?: [ 
          {
            name?: string(name='Name'),
            value?: string(name='Value'),
          }
        ](name='DisplayInfo'),
        id?: string(name='Id'),
        lang?: string(name='Lang'),
        name?: string(name='Name'),
        neighborList?: [ 
          {
            count?: int32(name='Count'),
            hasMore?: boolean(name='HasMore'),
            type?: string(name='Type'),
          }
        ](name='NeighborList'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='VertexList'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model DescribeGraph4InvestigationOnlineResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeGraph4InvestigationOnlineResponseBody(name='body'),
}

async function describeGraph4InvestigationOnlineWithOptions(tmpReq: DescribeGraph4InvestigationOnlineRequest, runtime: Util.RuntimeOptions): DescribeGraph4InvestigationOnlineResponse {
  Util.validateModel(tmpReq);
  var request = new DescribeGraph4InvestigationOnlineShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.ruleIdList)) {
    request.ruleIdListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.ruleIdList, 'RuleIdList', 'json');
  }
  if (!Util.isUnset(tmpReq.vertexIdList)) {
    request.vertexIdListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.vertexIdList, 'VertexIdList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.anomalyId)) {
    query['AnomalyId'] = request.anomalyId;
  }
  if (!Util.isUnset(request.anomalyUuid)) {
    query['AnomalyUuid'] = request.anomalyUuid;
  }
  if (!Util.isUnset(request.direction)) {
    query['Direction'] = request.direction;
  }
  if (!Util.isUnset(request.fromTime)) {
    query['FromTime'] = request.fromTime;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.pathLength)) {
    query['PathLength'] = request.pathLength;
  }
  if (!Util.isUnset(request.query)) {
    query['Query'] = request.query;
  }
  if (!Util.isUnset(request.ruleIdListShrink)) {
    query['RuleIdList'] = request.ruleIdListShrink;
  }
  if (!Util.isUnset(request.storeType)) {
    query['StoreType'] = request.storeType;
  }
  if (!Util.isUnset(request.toTime)) {
    query['ToTime'] = request.toTime;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  if (!Util.isUnset(request.vertexId)) {
    query['VertexId'] = request.vertexId;
  }
  if (!Util.isUnset(request.vertexIdListShrink)) {
    query['VertexIdList'] = request.vertexIdListShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeGraph4InvestigationOnline',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeGraph4InvestigationOnline(request: DescribeGraph4InvestigationOnlineRequest): DescribeGraph4InvestigationOnlineResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeGraph4InvestigationOnlineWithOptions(request, runtime);
}

model DescribeHasGraphRequest {
  aliUid?: long(name='AliUid'),
  securityAlarmList?: [ 
    {
      alarmUniqueInfo?: string(name='AlarmUniqueInfo'),
      securityEventList?: [ 
        {
          occurrenceTime?: string(name='OccurrenceTime'),
          uniqueInfo?: string(name='UniqueInfo'),
        }
      ](name='SecurityEventList'),
      uuid?: string(name='Uuid'),
    }
  ](name='SecurityAlarmList'),
}

model DescribeHasGraphShrinkRequest {
  aliUid?: long(name='AliUid'),
  securityAlarmListShrink?: string(name='SecurityAlarmList'),
}

model DescribeHasGraphResponseBody = {
  code?: string(name='Code'),
  data?: map[string]boolean(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model DescribeHasGraphResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeHasGraphResponseBody(name='body'),
}

async function describeHasGraphWithOptions(tmpReq: DescribeHasGraphRequest, runtime: Util.RuntimeOptions): DescribeHasGraphResponse {
  Util.validateModel(tmpReq);
  var request = new DescribeHasGraphShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.securityAlarmList)) {
    request.securityAlarmListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.securityAlarmList, 'SecurityAlarmList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.securityAlarmListShrink)) {
    query['SecurityAlarmList'] = request.securityAlarmListShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeHasGraph',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeHasGraph(request: DescribeHasGraphRequest): DescribeHasGraphResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeHasGraphWithOptions(request, runtime);
}

model DescribeLoginLogsRequest {
  aliUid?: long(name='AliUid'),
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  remark?: string(name='Remark'),
  statuses?: string(name='Statuses'),
  tag?: string(name='Tag'),
  types?: string(name='Types'),
}

model DescribeLoginLogsResponseBody = {
  currentPage?: int32(name='CurrentPage'),
  logList?: {
    logList?: [ 
    {
      groupId?: long(name='GroupId'),
      instanceId?: string(name='InstanceId'),
      instanceName?: string(name='InstanceName'),
      ip?: string(name='Ip'),
      location?: string(name='Location'),
      loginSourceIp?: string(name='LoginSourceIp'),
      loginTime?: long(name='LoginTime'),
      online?: string(name='Online'),
      osVersion?: string(name='OsVersion'),
      protocol?: int32(name='Protocol'),
      protocolName?: string(name='ProtocolName'),
      region?: string(name='Region'),
      status?: int32(name='Status'),
      type?: string(name='Type'),
      userName?: string(name='UserName'),
      uuid?: string(name='Uuid'),
      id?: long(name='id'),
    }
  ](name='LogList')
  }(name='LogList'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeLoginLogsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeLoginLogsResponseBody(name='body'),
}

async function describeLoginLogsWithOptions(request: DescribeLoginLogsRequest, runtime: Util.RuntimeOptions): DescribeLoginLogsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.remark)) {
    query['Remark'] = request.remark;
  }
  if (!Util.isUnset(request.statuses)) {
    query['Statuses'] = request.statuses;
  }
  if (!Util.isUnset(request.tag)) {
    query['Tag'] = request.tag;
  }
  if (!Util.isUnset(request.types)) {
    query['Types'] = request.types;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeLoginLogs',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeLoginLogs(request: DescribeLoginLogsRequest): DescribeLoginLogsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeLoginLogsWithOptions(request, runtime);
}

model DescribeMachineInfoOpersRequest {
  aliUid?: long(name='AliUid'),
  clientVersion?: string(name='ClientVersion'),
  currentPage?: int32(name='CurrentPage'),
  gcLevels?: string(name='GcLevels'),
  IPs?: string(name='IPs'),
  online?: boolean(name='Online'),
  pageSize?: int32(name='PageSize'),
  platform?: string(name='Platform'),
  updateVersion?: string(name='UpdateVersion'),
  uuids?: string(name='Uuids'),
}

model DescribeMachineInfoOpersResponseBody = {
  count?: int32(name='Count'),
  currentPage?: int32(name='CurrentPage'),
  machineInfoOpers?: {
    machineInfoOper?: [ 
    {
      aliUid?: long(name='AliUid'),
      clientIp?: string(name='ClientIp'),
      clientVersion?: string(name='ClientVersion'),
      gcLevel?: string(name='GcLevel'),
      modifiedTime?: string(name='ModifiedTime'),
      online?: boolean(name='Online'),
      platform?: string(name='Platform'),
      uuid?: string(name='Uuid'),
      updateVersion?: string(name='updateVersion'),
    }
  ](name='MachineInfoOper')
  }(name='MachineInfoOpers'),
  pageSize?: int32(name='PageSize'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeMachineInfoOpersResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeMachineInfoOpersResponseBody(name='body'),
}

async function describeMachineInfoOpersWithOptions(request: DescribeMachineInfoOpersRequest, runtime: Util.RuntimeOptions): DescribeMachineInfoOpersResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.clientVersion)) {
    query['ClientVersion'] = request.clientVersion;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.gcLevels)) {
    query['GcLevels'] = request.gcLevels;
  }
  if (!Util.isUnset(request.IPs)) {
    query['IPs'] = request.IPs;
  }
  if (!Util.isUnset(request.online)) {
    query['Online'] = request.online;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.platform)) {
    query['Platform'] = request.platform;
  }
  if (!Util.isUnset(request.updateVersion)) {
    query['UpdateVersion'] = request.updateVersion;
  }
  if (!Util.isUnset(request.uuids)) {
    query['Uuids'] = request.uuids;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeMachineInfoOpers',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeMachineInfoOpers(request: DescribeMachineInfoOpersRequest): DescribeMachineInfoOpersResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeMachineInfoOpersWithOptions(request, runtime);
}

model DescribeMachineInfoOpersByIpsRequest {
  aliUid?: long(name='AliUid'),
  clientVersion?: string(name='ClientVersion'),
  currentPage?: int32(name='CurrentPage'),
  gcLevels?: string(name='GcLevels'),
  IPs?: string(name='IPs'),
  online?: boolean(name='Online'),
  pageSize?: int32(name='PageSize'),
  platform?: string(name='Platform'),
  updateVersion?: string(name='UpdateVersion'),
  uuids?: string(name='Uuids'),
}

model DescribeMachineInfoOpersByIpsResponseBody = {
  count?: int32(name='Count'),
  currentPage?: int32(name='CurrentPage'),
  machineInfoOpers?: {
    machineInfoOper?: [ 
    {
      aliUid?: long(name='AliUid'),
      clientIp?: string(name='ClientIp'),
      clientVersion?: string(name='ClientVersion'),
      gcLevel?: string(name='GcLevel'),
      modifiedTime?: string(name='ModifiedTime'),
      online?: boolean(name='Online'),
      platform?: string(name='Platform'),
      uuid?: string(name='Uuid'),
      updateVersion?: string(name='updateVersion'),
    }
  ](name='MachineInfoOper')
  }(name='MachineInfoOpers'),
  pageSize?: int32(name='PageSize'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeMachineInfoOpersByIpsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeMachineInfoOpersByIpsResponseBody(name='body'),
}

async function describeMachineInfoOpersByIpsWithOptions(request: DescribeMachineInfoOpersByIpsRequest, runtime: Util.RuntimeOptions): DescribeMachineInfoOpersByIpsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.clientVersion)) {
    query['ClientVersion'] = request.clientVersion;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.gcLevels)) {
    query['GcLevels'] = request.gcLevels;
  }
  if (!Util.isUnset(request.IPs)) {
    query['IPs'] = request.IPs;
  }
  if (!Util.isUnset(request.online)) {
    query['Online'] = request.online;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.platform)) {
    query['Platform'] = request.platform;
  }
  if (!Util.isUnset(request.updateVersion)) {
    query['UpdateVersion'] = request.updateVersion;
  }
  if (!Util.isUnset(request.uuids)) {
    query['Uuids'] = request.uuids;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeMachineInfoOpersByIps',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeMachineInfoOpersByIps(request: DescribeMachineInfoOpersByIpsRequest): DescribeMachineInfoOpersByIpsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeMachineInfoOpersByIpsWithOptions(request, runtime);
}

model DescribeMachineInfoOpersByUuidsRequest {
  aliUid?: long(name='AliUid'),
  clientVersion?: string(name='ClientVersion'),
  currentPage?: int32(name='CurrentPage'),
  gcLevels?: string(name='GcLevels'),
  IPs?: string(name='IPs'),
  online?: boolean(name='Online'),
  pageSize?: int32(name='PageSize'),
  platform?: string(name='Platform'),
  updateVersion?: string(name='UpdateVersion'),
  uuids?: string(name='Uuids'),
}

model DescribeMachineInfoOpersByUuidsResponseBody = {
  count?: int32(name='Count'),
  currentPage?: int32(name='CurrentPage'),
  machineInfoOpers?: {
    machineInfoOper?: [ 
    {
      aliUid?: long(name='AliUid'),
      clientIp?: string(name='ClientIp'),
      clientVersion?: string(name='ClientVersion'),
      gcLevel?: string(name='GcLevel'),
      modifiedTime?: string(name='ModifiedTime'),
      online?: boolean(name='Online'),
      platform?: string(name='Platform'),
      uuid?: string(name='Uuid'),
      updateVersion?: string(name='updateVersion'),
    }
  ](name='MachineInfoOper')
  }(name='MachineInfoOpers'),
  pageSize?: int32(name='PageSize'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeMachineInfoOpersByUuidsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeMachineInfoOpersByUuidsResponseBody(name='body'),
}

async function describeMachineInfoOpersByUuidsWithOptions(request: DescribeMachineInfoOpersByUuidsRequest, runtime: Util.RuntimeOptions): DescribeMachineInfoOpersByUuidsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.clientVersion)) {
    query['ClientVersion'] = request.clientVersion;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.gcLevels)) {
    query['GcLevels'] = request.gcLevels;
  }
  if (!Util.isUnset(request.IPs)) {
    query['IPs'] = request.IPs;
  }
  if (!Util.isUnset(request.online)) {
    query['Online'] = request.online;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.platform)) {
    query['Platform'] = request.platform;
  }
  if (!Util.isUnset(request.updateVersion)) {
    query['UpdateVersion'] = request.updateVersion;
  }
  if (!Util.isUnset(request.uuids)) {
    query['Uuids'] = request.uuids;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeMachineInfoOpersByUuids',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeMachineInfoOpersByUuids(request: DescribeMachineInfoOpersByUuidsRequest): DescribeMachineInfoOpersByUuidsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeMachineInfoOpersByUuidsWithOptions(request, runtime);
}

model DescribeStaticFileRequest {
  taskId?: string(name='TaskId'),
}

model DescribeStaticFileResponseBody = {
  fileUploadServerInfos?: {
    fileUploadServerInfo?: [ 
    {
      localMd5?: string(name='LocalMd5'),
      message?: string(name='Message'),
      result?: string(name='Result'),
      serverIp?: string(name='ServerIp'),
    }
  ](name='FileUploadServerInfo')
  }(name='FileUploadServerInfos'),
}

model DescribeStaticFileResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeStaticFileResponseBody(name='body'),
}

async function describeStaticFileWithOptions(request: DescribeStaticFileRequest, runtime: Util.RuntimeOptions): DescribeStaticFileResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeStaticFile',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeStaticFile(request: DescribeStaticFileRequest): DescribeStaticFileResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeStaticFileWithOptions(request, runtime);
}

model DescribeSuspEventTracingGraphRequest {
  aliUid?: long(name='AliUid'),
  assetName?: string(name='AssetName'),
  bid?: string(name='Bid'),
  currentPage?: int32(name='CurrentPage'),
  lang?: string(name='Lang'),
  maxId?: long(name='MaxId'),
  pageSize?: int32(name='PageSize'),
  uniqueInfoList?: [ string ](name='UniqueInfoList'),
  uuid?: string(name='Uuid'),
  vertexId?: string(name='VertexId'),
}

model DescribeSuspEventTracingGraphShrinkRequest {
  aliUid?: long(name='AliUid'),
  assetName?: string(name='AssetName'),
  bid?: string(name='Bid'),
  currentPage?: int32(name='CurrentPage'),
  lang?: string(name='Lang'),
  maxId?: long(name='MaxId'),
  pageSize?: int32(name='PageSize'),
  uniqueInfoListShrink?: string(name='UniqueInfoList'),
  uuid?: string(name='Uuid'),
  vertexId?: string(name='VertexId'),
}

model DescribeSuspEventTracingGraphResponseBody = {
  code?: string(name='Code'),
  data?: {
    edgeList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        endId?: string(name='EndId'),
        endType?: string(name='EndType'),
        name?: string(name='Name'),
        origin?: string(name='Origin'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        showType?: string(name='ShowType'),
        startId?: string(name='StartId'),
        startType?: string(name='StartType'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        typeName?: string(name='TypeName'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='EdgeList'),
    vertexList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        displayInfo?: [ 
          {
            name?: string(name='Name'),
            value?: string(name='Value'),
          }
        ](name='DisplayInfo'),
        id?: string(name='Id'),
        lang?: string(name='Lang'),
        name?: string(name='Name'),
        neighborList?: [ 
          {
            count?: int32(name='Count'),
            hasMore?: boolean(name='HasMore'),
            type?: string(name='Type'),
          }
        ](name='NeighborList'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='VertexList'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model DescribeSuspEventTracingGraphResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeSuspEventTracingGraphResponseBody(name='body'),
}

async function describeSuspEventTracingGraphWithOptions(tmpReq: DescribeSuspEventTracingGraphRequest, runtime: Util.RuntimeOptions): DescribeSuspEventTracingGraphResponse {
  Util.validateModel(tmpReq);
  var request = new DescribeSuspEventTracingGraphShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.uniqueInfoList)) {
    request.uniqueInfoListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.uniqueInfoList, 'UniqueInfoList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.assetName)) {
    query['AssetName'] = request.assetName;
  }
  if (!Util.isUnset(request.bid)) {
    query['Bid'] = request.bid;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.maxId)) {
    query['MaxId'] = request.maxId;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.uniqueInfoListShrink)) {
    query['UniqueInfoList'] = request.uniqueInfoListShrink;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  if (!Util.isUnset(request.vertexId)) {
    query['VertexId'] = request.vertexId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSuspEventTracingGraph',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSuspEventTracingGraph(request: DescribeSuspEventTracingGraphRequest): DescribeSuspEventTracingGraphResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSuspEventTracingGraphWithOptions(request, runtime);
}

model DescribeSuspEventTracingMetaInfoRequest {
  aliUid?: long(name='AliUid'),
  bid?: string(name='Bid'),
  currentPage?: int32(name='CurrentPage'),
  lang?: string(name='Lang'),
  maxId?: long(name='MaxId'),
  pageSize?: int32(name='PageSize'),
}

model DescribeSuspEventTracingMetaInfoResponseBody = {
  code?: string(name='Code'),
  data?: {
    edgeList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        endId?: string(name='EndId'),
        endType?: string(name='EndType'),
        name?: string(name='Name'),
        origin?: string(name='Origin'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        showType?: string(name='ShowType'),
        startId?: string(name='StartId'),
        startType?: string(name='StartType'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        typeName?: string(name='TypeName'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='EdgeList'),
    entityTypeList?: [ 
      {
        currentVersionId?: string(name='CurrentVersionId'),
        displayColor?: string(name='DisplayColor'),
        displayIcon?: string(name='DisplayIcon'),
        displayOrder?: int32(name='DisplayOrder'),
        displayTemplate?: string(name='DisplayTemplate'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: string(name='Id'),
        isVirtualNode?: int32(name='IsVirtualNode'),
        name?: string(name='Name'),
        namespace?: string(name='Namespace'),
        syncId?: int32(name='SyncId'),
        traceSuccessFlag?: int32(name='TraceSuccessFlag'),
      }
    ](name='EntityTypeList'),
    lang?: string(name='Lang'),
    relationTypeList?: [ 
      {
        currentVersionId?: string(name='CurrentVersionId'),
        directed?: int32(name='Directed'),
        displayColor?: string(name='DisplayColor'),
        displayIcon?: string(name='DisplayIcon'),
        displayTemplate?: string(name='DisplayTemplate'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: string(name='Id'),
        name?: string(name='Name'),
        namespace?: string(name='Namespace'),
        showType?: string(name='ShowType'),
        syncId?: int32(name='SyncId'),
      }
    ](name='RelationTypeList'),
    vertexList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        displayInfo?: [ 
          {
            name?: string(name='Name'),
            value?: string(name='Value'),
          }
        ](name='DisplayInfo'),
        id?: string(name='Id'),
        lang?: string(name='Lang'),
        name?: string(name='Name'),
        neighborList?: [ 
          {
            count?: int32(name='Count'),
            hasMore?: boolean(name='HasMore'),
            type?: string(name='Type'),
          }
        ](name='NeighborList'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='VertexList'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model DescribeSuspEventTracingMetaInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeSuspEventTracingMetaInfoResponseBody(name='body'),
}

async function describeSuspEventTracingMetaInfoWithOptions(request: DescribeSuspEventTracingMetaInfoRequest, runtime: Util.RuntimeOptions): DescribeSuspEventTracingMetaInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.bid)) {
    query['Bid'] = request.bid;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.maxId)) {
    query['MaxId'] = request.maxId;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSuspEventTracingMetaInfo',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSuspEventTracingMetaInfo(request: DescribeSuspEventTracingMetaInfoRequest): DescribeSuspEventTracingMetaInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSuspEventTracingMetaInfoWithOptions(request, runtime);
}

model DescribeSuspEventTracingSubNodesCountRequest {
  aliUid?: long(name='AliUid'),
  bid?: string(name='Bid'),
  currentPage?: int32(name='CurrentPage'),
  lang?: string(name='Lang'),
  maxId?: long(name='MaxId'),
  pageSize?: int32(name='PageSize'),
  uuid?: string(name='Uuid'),
  vertexList?: [ 
    {
      aliuid?: string(name='Aliuid'),
      displayInfo?: [ 
        {
          name?: string(name='Name'),
          value?: string(name='Value'),
        }
      ](name='DisplayInfo'),
      id?: string(name='Id'),
      lang?: string(name='Lang'),
      name?: string(name='Name'),
      neighborList?: [ 
        {
          count?: int32(name='Count'),
          hasMore?: boolean(name='HasMore'),
          type?: string(name='Type'),
        }
      ](name='NeighborList'),
      properties?: string(name='Properties'),
      property?: map[string]any(name='Property'),
      ruleId?: string(name='RuleId'),
      time?: string(name='Time'),
      timestamp?: long(name='Timestamp'),
      type?: string(name='Type'),
      updateTime?: string(name='UpdateTime'),
      uuid?: string(name='Uuid'),
    }
  ](name='VertexList'),
}

model DescribeSuspEventTracingSubNodesCountShrinkRequest {
  aliUid?: long(name='AliUid'),
  bid?: string(name='Bid'),
  currentPage?: int32(name='CurrentPage'),
  lang?: string(name='Lang'),
  maxId?: long(name='MaxId'),
  pageSize?: int32(name='PageSize'),
  uuid?: string(name='Uuid'),
  vertexListShrink?: string(name='VertexList'),
}

model DescribeSuspEventTracingSubNodesCountResponseBody = {
  code?: string(name='Code'),
  data?: map[string]int32(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model DescribeSuspEventTracingSubNodesCountResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeSuspEventTracingSubNodesCountResponseBody(name='body'),
}

async function describeSuspEventTracingSubNodesCountWithOptions(tmpReq: DescribeSuspEventTracingSubNodesCountRequest, runtime: Util.RuntimeOptions): DescribeSuspEventTracingSubNodesCountResponse {
  Util.validateModel(tmpReq);
  var request = new DescribeSuspEventTracingSubNodesCountShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.vertexList)) {
    request.vertexListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.vertexList, 'VertexList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.bid)) {
    query['Bid'] = request.bid;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.maxId)) {
    query['MaxId'] = request.maxId;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  if (!Util.isUnset(request.vertexListShrink)) {
    query['VertexList'] = request.vertexListShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSuspEventTracingSubNodesCount',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSuspEventTracingSubNodesCount(request: DescribeSuspEventTracingSubNodesCountRequest): DescribeSuspEventTracingSubNodesCountResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSuspEventTracingSubNodesCountWithOptions(request, runtime);
}

model DescribeSuspEventTracingSubNodesQueryRequest {
  aliUid?: long(name='AliUid'),
  edgeTypeList?: [ string ](name='EdgeTypeList'),
  lang?: string(name='Lang'),
  offset?: long(name='Offset'),
  size?: int32(name='Size'),
  type?: string(name='Type'),
  uuid?: string(name='Uuid'),
  vertexId?: string(name='VertexId'),
}

model DescribeSuspEventTracingSubNodesQueryShrinkRequest {
  aliUid?: long(name='AliUid'),
  edgeTypeListShrink?: string(name='EdgeTypeList'),
  lang?: string(name='Lang'),
  offset?: long(name='Offset'),
  size?: int32(name='Size'),
  type?: string(name='Type'),
  uuid?: string(name='Uuid'),
  vertexId?: string(name='VertexId'),
}

model DescribeSuspEventTracingSubNodesQueryResponseBody = {
  code?: string(name='Code'),
  data?: {
    edgeList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        endId?: string(name='EndId'),
        endType?: string(name='EndType'),
        name?: string(name='Name'),
        origin?: string(name='Origin'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        showType?: string(name='ShowType'),
        startId?: string(name='StartId'),
        startType?: string(name='StartType'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        typeName?: string(name='TypeName'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='EdgeList'),
    vertexList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        displayInfo?: [ 
          {
            name?: string(name='Name'),
            value?: string(name='Value'),
          }
        ](name='DisplayInfo'),
        id?: string(name='Id'),
        lang?: string(name='Lang'),
        name?: string(name='Name'),
        neighborList?: [ 
          {
            count?: int32(name='Count'),
            hasMore?: boolean(name='HasMore'),
            type?: string(name='Type'),
          }
        ](name='NeighborList'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='VertexList'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model DescribeSuspEventTracingSubNodesQueryResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeSuspEventTracingSubNodesQueryResponseBody(name='body'),
}

async function describeSuspEventTracingSubNodesQueryWithOptions(tmpReq: DescribeSuspEventTracingSubNodesQueryRequest, runtime: Util.RuntimeOptions): DescribeSuspEventTracingSubNodesQueryResponse {
  Util.validateModel(tmpReq);
  var request = new DescribeSuspEventTracingSubNodesQueryShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.edgeTypeList)) {
    request.edgeTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.edgeTypeList, 'EdgeTypeList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.edgeTypeListShrink)) {
    query['EdgeTypeList'] = request.edgeTypeListShrink;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.offset)) {
    query['Offset'] = request.offset;
  }
  if (!Util.isUnset(request.size)) {
    query['Size'] = request.size;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  if (!Util.isUnset(request.vertexId)) {
    query['VertexId'] = request.vertexId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSuspEventTracingSubNodesQuery',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSuspEventTracingSubNodesQuery(request: DescribeSuspEventTracingSubNodesQueryRequest): DescribeSuspEventTracingSubNodesQueryResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSuspEventTracingSubNodesQueryWithOptions(request, runtime);
}

model DescribeSuspEventTracingVertexExtendInfoRequest {
  aliUid?: long(name='AliUid'),
  bid?: string(name='Bid'),
  currentPage?: int32(name='CurrentPage'),
  edgeType?: string(name='EdgeType'),
  lang?: string(name='Lang'),
  maxId?: long(name='MaxId'),
  offset?: long(name='Offset'),
  pageSize?: int32(name='PageSize'),
  size?: int32(name='Size'),
  type?: string(name='Type'),
  uuid?: string(name='Uuid'),
  vertexId?: string(name='VertexId'),
}

model DescribeSuspEventTracingVertexExtendInfoResponseBody = {
  code?: string(name='Code'),
  count?: int32(name='Count'),
  data?: [ 
    {
      aliuid?: string(name='Aliuid'),
      displayInfo?: [ 
        {
          name?: string(name='Name'),
          value?: string(name='Value'),
        }
      ](name='DisplayInfo'),
      id?: string(name='Id'),
      lang?: string(name='Lang'),
      name?: string(name='Name'),
      neighborList?: [ 
        {
          count?: int32(name='Count'),
          hasMore?: boolean(name='HasMore'),
          type?: string(name='Type'),
        }
      ](name='NeighborList'),
      properties?: string(name='Properties'),
      property?: map[string]any(name='Property'),
      ruleId?: string(name='RuleId'),
      time?: string(name='Time'),
      timestamp?: long(name='Timestamp'),
      type?: string(name='Type'),
      updateTime?: string(name='UpdateTime'),
      uuid?: string(name='Uuid'),
    }
  ](name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model DescribeSuspEventTracingVertexExtendInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeSuspEventTracingVertexExtendInfoResponseBody(name='body'),
}

async function describeSuspEventTracingVertexExtendInfoWithOptions(request: DescribeSuspEventTracingVertexExtendInfoRequest, runtime: Util.RuntimeOptions): DescribeSuspEventTracingVertexExtendInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.bid)) {
    query['Bid'] = request.bid;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.edgeType)) {
    query['EdgeType'] = request.edgeType;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.maxId)) {
    query['MaxId'] = request.maxId;
  }
  if (!Util.isUnset(request.offset)) {
    query['Offset'] = request.offset;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.size)) {
    query['Size'] = request.size;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  if (!Util.isUnset(request.vertexId)) {
    query['VertexId'] = request.vertexId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSuspEventTracingVertexExtendInfo',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSuspEventTracingVertexExtendInfo(request: DescribeSuspEventTracingVertexExtendInfoRequest): DescribeSuspEventTracingVertexExtendInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSuspEventTracingVertexExtendInfoWithOptions(request, runtime);
}

model DescribeUploadHistoryResponseBody = {
  fileUploadHistoryInfos?: {
    fileUploadHistoryInfo?: [ 
    {
      filePath?: string(name='FilePath'),
      ossKey?: string(name='OssKey'),
      taskId?: string(name='TaskId'),
    }
  ](name='FileUploadHistoryInfo')
  }(name='FileUploadHistoryInfos'),
}

model DescribeUploadHistoryResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeUploadHistoryResponseBody(name='body'),
}

async function describeUploadHistoryWithOptions(runtime: Util.RuntimeOptions): DescribeUploadHistoryResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'DescribeUploadHistory',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeUploadHistory(): DescribeUploadHistoryResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUploadHistoryWithOptions(runtime);
}

model DescribeUploadStatusRequest {
  filePath?: string(name='FilePath'),
  ossKey?: string(name='OssKey'),
  ossMd5?: string(name='OssMd5'),
  taskId?: string(name='TaskId'),
  unZip?: boolean(name='UnZip'),
}

model DescribeUploadStatusResponseBody = {
  fileUploadServerInfos?: {
    fileUploadServerInfo?: [ 
    {
      localMd5?: string(name='LocalMd5'),
      message?: string(name='Message'),
      result?: string(name='Result'),
      serverIp?: string(name='ServerIp'),
    }
  ](name='FileUploadServerInfo')
  }(name='FileUploadServerInfos'),
}

model DescribeUploadStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeUploadStatusResponseBody(name='body'),
}

async function describeUploadStatusWithOptions(request: DescribeUploadStatusRequest, runtime: Util.RuntimeOptions): DescribeUploadStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.filePath)) {
    query['FilePath'] = request.filePath;
  }
  if (!Util.isUnset(request.ossKey)) {
    query['OssKey'] = request.ossKey;
  }
  if (!Util.isUnset(request.ossMd5)) {
    query['OssMd5'] = request.ossMd5;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.unZip)) {
    query['UnZip'] = request.unZip;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeUploadStatus',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeUploadStatus(request: DescribeUploadStatusRequest): DescribeUploadStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUploadStatusWithOptions(request, runtime);
}

model DescribeVertexDetailRequest {
  aliUid?: long(name='AliUid'),
  incidentTime?: string(name='IncidentTime'),
  lang?: string(name='Lang'),
  limit?: int32(name='Limit'),
  offset?: int32(name='Offset'),
  startType?: string(name='StartType'),
  type?: string(name='Type'),
  userLevel?: string(name='UserLevel'),
  uuid?: string(name='Uuid'),
  vertexId?: string(name='VertexId'),
}

model DescribeVertexDetailResponseBody = {
  code?: string(name='Code'),
  data?: {
    aliuid?: string(name='Aliuid'),
    displayInfo?: [ 
      {
        name?: string(name='Name'),
        value?: string(name='Value'),
      }
    ](name='DisplayInfo'),
    id?: string(name='Id'),
    lang?: string(name='Lang'),
    name?: string(name='Name'),
    neighborList?: [ 
      {
        count?: int32(name='Count'),
        hasMore?: boolean(name='HasMore'),
        type?: string(name='Type'),
      }
    ](name='NeighborList'),
    properties?: string(name='Properties'),
    property?: map[string]any(name='Property'),
    ruleId?: string(name='RuleId'),
    time?: string(name='Time'),
    timestamp?: long(name='Timestamp'),
    type?: string(name='Type'),
    updateTime?: string(name='UpdateTime'),
    uuid?: string(name='Uuid'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model DescribeVertexDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeVertexDetailResponseBody(name='body'),
}

async function describeVertexDetailWithOptions(request: DescribeVertexDetailRequest, runtime: Util.RuntimeOptions): DescribeVertexDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.incidentTime)) {
    query['IncidentTime'] = request.incidentTime;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.limit)) {
    query['Limit'] = request.limit;
  }
  if (!Util.isUnset(request.offset)) {
    query['Offset'] = request.offset;
  }
  if (!Util.isUnset(request.startType)) {
    query['StartType'] = request.startType;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.userLevel)) {
    query['UserLevel'] = request.userLevel;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  if (!Util.isUnset(request.vertexId)) {
    query['VertexId'] = request.vertexId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeVertexDetail',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeVertexDetail(request: DescribeVertexDetailRequest): DescribeVertexDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeVertexDetailWithOptions(request, runtime);
}

model DescribeVertexListRequest {
  aliUid?: long(name='AliUid'),
  incidentTime?: string(name='IncidentTime'),
  lang?: string(name='Lang'),
  limit?: int32(name='Limit'),
  offset?: int32(name='Offset'),
  startType?: string(name='StartType'),
  type?: string(name='Type'),
  userLevel?: string(name='UserLevel'),
  uuid?: string(name='Uuid'),
  vertexId?: string(name='VertexId'),
}

model DescribeVertexListResponseBody = {
  code?: string(name='Code'),
  data?: {
    edgeList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        endId?: string(name='EndId'),
        endType?: string(name='EndType'),
        name?: string(name='Name'),
        origin?: string(name='Origin'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        showType?: string(name='ShowType'),
        startId?: string(name='StartId'),
        startType?: string(name='StartType'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        typeName?: string(name='TypeName'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='EdgeList'),
    entityTypeList?: [ 
      {
        currentVersionId?: string(name='CurrentVersionId'),
        displayColor?: string(name='DisplayColor'),
        displayIcon?: string(name='DisplayIcon'),
        displayOrder?: int32(name='DisplayOrder'),
        displayTemplate?: string(name='DisplayTemplate'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: string(name='Id'),
        isVirtualNode?: int32(name='IsVirtualNode'),
        name?: string(name='Name'),
        namespace?: string(name='Namespace'),
        syncId?: int32(name='SyncId'),
        traceSuccessFlag?: int32(name='TraceSuccessFlag'),
      }
    ](name='EntityTypeList'),
    lang?: string(name='Lang'),
    relationTypeList?: [ 
      {
        currentVersionId?: string(name='CurrentVersionId'),
        directed?: int32(name='Directed'),
        displayColor?: string(name='DisplayColor'),
        displayIcon?: string(name='DisplayIcon'),
        displayTemplate?: string(name='DisplayTemplate'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: string(name='Id'),
        name?: string(name='Name'),
        namespace?: string(name='Namespace'),
        showType?: string(name='ShowType'),
        syncId?: int32(name='SyncId'),
      }
    ](name='RelationTypeList'),
    vertexList?: [ 
      {
        aliuid?: string(name='Aliuid'),
        displayInfo?: [ 
          {
            name?: string(name='Name'),
            value?: string(name='Value'),
          }
        ](name='DisplayInfo'),
        id?: string(name='Id'),
        lang?: string(name='Lang'),
        name?: string(name='Name'),
        neighborList?: [ 
          {
            count?: int32(name='Count'),
            hasMore?: boolean(name='HasMore'),
            type?: string(name='Type'),
          }
        ](name='NeighborList'),
        properties?: string(name='Properties'),
        property?: map[string]any(name='Property'),
        ruleId?: string(name='RuleId'),
        time?: string(name='Time'),
        timestamp?: long(name='Timestamp'),
        type?: string(name='Type'),
        updateTime?: string(name='UpdateTime'),
        uuid?: string(name='Uuid'),
      }
    ](name='VertexList'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model DescribeVertexListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DescribeVertexListResponseBody(name='body'),
}

async function describeVertexListWithOptions(request: DescribeVertexListRequest, runtime: Util.RuntimeOptions): DescribeVertexListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.incidentTime)) {
    query['IncidentTime'] = request.incidentTime;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.limit)) {
    query['Limit'] = request.limit;
  }
  if (!Util.isUnset(request.offset)) {
    query['Offset'] = request.offset;
  }
  if (!Util.isUnset(request.startType)) {
    query['StartType'] = request.startType;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.userLevel)) {
    query['UserLevel'] = request.userLevel;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  if (!Util.isUnset(request.vertexId)) {
    query['VertexId'] = request.vertexId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeVertexList',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeVertexList(request: DescribeVertexListRequest): DescribeVertexListResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeVertexListWithOptions(request, runtime);
}

model ListQueryRaspAppInfoInnerRequest {
  uuids?: string(name='Uuids'),
}

model ListQueryRaspAppInfoInnerResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      raspAppName?: string(name='RaspAppName'),
      raspOnlineStatus?: int32(name='RaspOnlineStatus'),
      raspStatus?: string(name='RaspStatus'),
      result?: string(name='Result'),
      uuid?: string(name='Uuid'),
    }
  ](name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListQueryRaspAppInfoInnerResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListQueryRaspAppInfoInnerResponseBody(name='body'),
}

async function listQueryRaspAppInfoInnerWithOptions(request: ListQueryRaspAppInfoInnerRequest, runtime: Util.RuntimeOptions): ListQueryRaspAppInfoInnerResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.uuids)) {
    query['Uuids'] = request.uuids;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListQueryRaspAppInfoInner',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listQueryRaspAppInfoInner(request: ListQueryRaspAppInfoInnerRequest): ListQueryRaspAppInfoInnerResponse {
  var runtime = new Util.RuntimeOptions{};
  return listQueryRaspAppInfoInnerWithOptions(request, runtime);
}

model OperateStaticFileRequest {
  filePath?: string(name='FilePath'),
  taskId?: string(name='TaskId'),
  type?: string(name='Type'),
}

model OperateStaticFileResponseBody = {
  result?: boolean(name='result'),
}

model OperateStaticFileResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OperateStaticFileResponseBody(name='body'),
}

async function operateStaticFileWithOptions(request: OperateStaticFileRequest, runtime: Util.RuntimeOptions): OperateStaticFileResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.filePath)) {
    query['FilePath'] = request.filePath;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OperateStaticFile',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function operateStaticFile(request: OperateStaticFileRequest): OperateStaticFileResponse {
  var runtime = new Util.RuntimeOptions{};
  return operateStaticFileWithOptions(request, runtime);
}

model PushCommondToClientRequest {
  appName?: string(name='AppName'),
  arg1?: string(name='Arg1'),
  arg2?: string(name='Arg2'),
  arg3?: string(name='Arg3'),
  methodName?: string(name='MethodName'),
  uuid?: string(name='Uuid'),
}

model PushCommondToClientResponseBody = {
  aegisRemoteCmdPushResponse?: {
    commandId?: string(name='CommandId'),
  }(name='AegisRemoteCmdPushResponse'),
}

model PushCommondToClientResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PushCommondToClientResponseBody(name='body'),
}

async function pushCommondToClientWithOptions(request: PushCommondToClientRequest, runtime: Util.RuntimeOptions): PushCommondToClientResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.appName)) {
    query['AppName'] = request.appName;
  }
  if (!Util.isUnset(request.arg1)) {
    query['Arg1'] = request.arg1;
  }
  if (!Util.isUnset(request.arg2)) {
    query['Arg2'] = request.arg2;
  }
  if (!Util.isUnset(request.arg3)) {
    query['Arg3'] = request.arg3;
  }
  if (!Util.isUnset(request.methodName)) {
    query['MethodName'] = request.methodName;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PushCommondToClient',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function pushCommondToClient(request: PushCommondToClientRequest): PushCommondToClientResponse {
  var runtime = new Util.RuntimeOptions{};
  return pushCommondToClientWithOptions(request, runtime);
}

model PushProtocolByUuidRequest {
  msg?: string(name='Msg'),
  protocolType?: string(name='ProtocolType'),
  uuid?: string(name='Uuid'),
}

model PushProtocolByUuidResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  result?: boolean(name='result'),
}

model PushProtocolByUuidResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PushProtocolByUuidResponseBody(name='body'),
}

async function pushProtocolByUuidWithOptions(request: PushProtocolByUuidRequest, runtime: Util.RuntimeOptions): PushProtocolByUuidResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.msg)) {
    query['Msg'] = request.msg;
  }
  if (!Util.isUnset(request.protocolType)) {
    query['ProtocolType'] = request.protocolType;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PushProtocolByUuid',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function pushProtocolByUuid(request: PushProtocolByUuidRequest): PushProtocolByUuidResponse {
  var runtime = new Util.RuntimeOptions{};
  return pushProtocolByUuidWithOptions(request, runtime);
}

model PushRtapTaskByUuidRequest {
  appName?: string(name='AppName'),
  data?: string(name='Data'),
  taskSN?: string(name='TaskSN'),
  uuid?: string(name='Uuid'),
}

model PushRtapTaskByUuidResponseBody = {
  aegisRtapTaskResponse?: {
    cmdIdx?: string(name='CmdIdx'),
    result?: boolean(name='Result'),
  }(name='AegisRtapTaskResponse'),
}

model PushRtapTaskByUuidResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PushRtapTaskByUuidResponseBody(name='body'),
}

async function pushRtapTaskByUuidWithOptions(request: PushRtapTaskByUuidRequest, runtime: Util.RuntimeOptions): PushRtapTaskByUuidResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.appName)) {
    query['AppName'] = request.appName;
  }
  if (!Util.isUnset(request.data)) {
    query['Data'] = request.data;
  }
  if (!Util.isUnset(request.taskSN)) {
    query['TaskSN'] = request.taskSN;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PushRtapTaskByUuid',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function pushRtapTaskByUuid(request: PushRtapTaskByUuidRequest): PushRtapTaskByUuidResponse {
  var runtime = new Util.RuntimeOptions{};
  return pushRtapTaskByUuidWithOptions(request, runtime);
}

model QueryCloudNativeTaskStatusRequest {
  aliUid?: long(name='AliUid'),
  bid?: string(name='Bid'),
  lang?: string(name='Lang'),
  requestId?: string(name='RequestId'),
  rootTaskId?: string(name='RootTaskId'),
  taskIds?: string(name='TaskIds'),
}

model QueryCloudNativeTaskStatusResponseBody = {
  code?: string(name='Code'),
  count?: int32(name='Count'),
  data?: [ 
    {
      aliUid?: long(name='AliUid'),
      process?: int32(name='Process'),
      result?: string(name='Result'),
      rootTaskId?: string(name='RootTaskId'),
      status?: string(name='Status'),
      taskId?: string(name='TaskId'),
      uuid?: string(name='Uuid'),
    }
  ](name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model QueryCloudNativeTaskStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryCloudNativeTaskStatusResponseBody(name='body'),
}

async function queryCloudNativeTaskStatusWithOptions(request: QueryCloudNativeTaskStatusRequest, runtime: Util.RuntimeOptions): QueryCloudNativeTaskStatusResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.aliUid)) {
    body['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.bid)) {
    body['Bid'] = request.bid;
  }
  if (!Util.isUnset(request.lang)) {
    body['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.requestId)) {
    body['RequestId'] = request.requestId;
  }
  if (!Util.isUnset(request.rootTaskId)) {
    body['RootTaskId'] = request.rootTaskId;
  }
  if (!Util.isUnset(request.taskIds)) {
    body['TaskIds'] = request.taskIds;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryCloudNativeTaskStatus',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryCloudNativeTaskStatus(request: QueryCloudNativeTaskStatusRequest): QueryCloudNativeTaskStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryCloudNativeTaskStatusWithOptions(request, runtime);
}

model SendMessageRequest {
  aliUid?: string(name='AliUid'),
  eventType?: string(name='EventType'),
  params?: map[string]any(name='Params'),
  uuid?: string(name='Uuid'),
}

model SendMessageShrinkRequest {
  aliUid?: string(name='AliUid'),
  eventType?: string(name='EventType'),
  paramsShrink?: string(name='Params'),
  uuid?: string(name='Uuid'),
}

model SendMessageResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SendMessageResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SendMessageResponseBody(name='body'),
}

async function sendMessageWithOptions(tmpReq: SendMessageRequest, runtime: Util.RuntimeOptions): SendMessageResponse {
  Util.validateModel(tmpReq);
  var request = new SendMessageShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.params)) {
    request.paramsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.params, 'Params', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.eventType)) {
    query['EventType'] = request.eventType;
  }
  if (!Util.isUnset(request.paramsShrink)) {
    query['Params'] = request.paramsShrink;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SendMessage',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function sendMessage(request: SendMessageRequest): SendMessageResponse {
  var runtime = new Util.RuntimeOptions{};
  return sendMessageWithOptions(request, runtime);
}

model SendUnifyNoticeMessageRequest {
  aliUid?: long(name='AliUid'),
  bid?: string(name='Bid'),
  eventType?: string(name='EventType'),
  lang?: string(name='Lang'),
  params?: string(name='Params'),
  requestId?: string(name='RequestId'),
  uuid?: string(name='Uuid'),
}

model SendUnifyNoticeMessageResponseBody = {
  code?: string(name='Code'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  timeCost?: long(name='TimeCost'),
}

model SendUnifyNoticeMessageResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SendUnifyNoticeMessageResponseBody(name='body'),
}

async function sendUnifyNoticeMessageWithOptions(request: SendUnifyNoticeMessageRequest, runtime: Util.RuntimeOptions): SendUnifyNoticeMessageResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.aliUid)) {
    body['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.bid)) {
    body['Bid'] = request.bid;
  }
  if (!Util.isUnset(request.eventType)) {
    body['EventType'] = request.eventType;
  }
  if (!Util.isUnset(request.lang)) {
    body['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.params)) {
    body['Params'] = request.params;
  }
  if (!Util.isUnset(request.requestId)) {
    body['RequestId'] = request.requestId;
  }
  if (!Util.isUnset(request.uuid)) {
    body['Uuid'] = request.uuid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SendUnifyNoticeMessage',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function sendUnifyNoticeMessage(request: SendUnifyNoticeMessageRequest): SendUnifyNoticeMessageResponse {
  var runtime = new Util.RuntimeOptions{};
  return sendUnifyNoticeMessageWithOptions(request, runtime);
}

model UploadStaticFileRequest {
  filePath?: string(name='FilePath'),
  ossKey?: string(name='OssKey'),
  ossMd5?: string(name='OssMd5'),
  taskId?: string(name='TaskId'),
  unZip?: boolean(name='UnZip'),
}

model UploadStaticFileResponseBody = {
  result?: boolean(name='result'),
}

model UploadStaticFileResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UploadStaticFileResponseBody(name='body'),
}

async function uploadStaticFileWithOptions(request: UploadStaticFileRequest, runtime: Util.RuntimeOptions): UploadStaticFileResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.filePath)) {
    query['FilePath'] = request.filePath;
  }
  if (!Util.isUnset(request.ossKey)) {
    query['OssKey'] = request.ossKey;
  }
  if (!Util.isUnset(request.ossMd5)) {
    query['OssMd5'] = request.ossMd5;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.unZip)) {
    query['UnZip'] = request.unZip;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UploadStaticFile',
    version = '2018-08-28',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function uploadStaticFile(request: UploadStaticFileRequest): UploadStaticFileResponse {
  var runtime = new Util.RuntimeOptions{};
  return uploadStaticFileWithOptions(request, runtime);
}

